/**
 * 一共N个点，初始时某些点已经有能量。
 * 对每一个有能量的点其价值为零，无能量的点其价值为左右有能量的能量之积
 * 初始保证1和N有能量。有两种操作：
 * 1 p v：在p位置插入能量v，保证p位置原来没有能量
 * 2 s e: 求[s, e]区间的价值和
 * 
 * 2操作显然是区间求和。
 * 考虑1操作，假设p位置原来位于[L, R]之间，也就是说要把[L, p - 1]和[p - 1, R]的价值修改成新的值即可
 * 因此1操作对应2个区间修改操作。
 * 剩下的只需要考虑对每一个p位置如何定位到[L, R]即可，显然维护空白区间二分。
 * 这份代码以为1操作修改的点数是O(N)的，因此使用了循环单点修改，但实际上最差可以做到平方，单点修改应该要T。
 * 但是过了。
 */
#include <bits/stdc++.h>
using namespace std;

using llt = long long;
using vi = vector<int>;
using Real = long double;

struct FenwickTree{ // 树状数组

using value_type = long long int;
using vec_type = vector<value_type>;

int n;
vec_type c;

FenwickTree() = default;

static int lowbit(int x){return x & -x;}

void init(int nn){this->c.assign((this->n=nn) + 1, 0);}

void modify(int pos, value_type delta){
    for(int i=pos;i<=this->n;i+=lowbit(i)) this->c[i] += delta;
}

value_type query(int pos)const{
    value_type ans = 0;
    for(int i=pos;i;i-=lowbit(i)) ans += this->c[i];
    return ans;
}

value_type query(int s, int e)const{return this->query(e) - this->query(s - 1);}

}Bt;


struct RangeTree{ // 区间集合

using key_t = pair<int, int>;
using value_t = int;

///pbds不支持范围erase操作
std::map<key_t, value_t> shu;

RangeTree():shu(){init();}

void init(){
    shu.clear();
    /// 插入哨兵
    shu.insert({{ninf(), ninf()}, value_zero()});
    shu.insert({{inf(), inf()}, value_zero()});
}

static int inf(){
    static const int INF = 0x7F7FFFFF;
    return INF;
}

static int ninf(){return -inf();}

static value_t value_zero(){
    static const value_t VALUE_ZERO = 0;
    return VALUE_ZERO;
}

/// 插入区间[a, b]，如有必要会有合并操作
void insert(int a, int b, const value_t & v = value_zero()){
    assert(not shu.empty() and a <= b);

    key_t toInsert;
    

    /// 找到a前面一个
    auto sit = shu.lower_bound({a, inf()});
    assert(sit != shu.begin() and sit != shu.end() and sit->first.first > a);
    --sit;

    decltype(sit) toDelBegin, toDelEnd;

    if(sit->first.second +1 >= a){
        toInsert.first = sit->first.first;
        toDelBegin = sit;
    }else{
        toInsert.first = a;
        toDelBegin = ++sit;
    }

    auto eit = shu.lower_bound({b, inf()});
    assert(eit != shu.begin() and eit != shu.end() and eit->first.first > b);

    if(eit->first.first == b + 1){
        toInsert.second = eit->first.second;
        toDelEnd = ++eit;
    }else{
        toDelEnd = eit;
        --eit;
        toInsert.second = max(eit->first.second, b);
    }

    if(toDelBegin != toDelEnd) {
        shu.erase(toDelBegin, toDelEnd);
    }
    shu.insert({toInsert, v});
    return;
}

}Tree;

int N, M, Q;
vector<int> X;
vector<llt> V;

void work(){
    cin >> N >> M >> Q;
    X.assign(M, {});
    for(auto & i : X) cin >> i;
    
    V.assign(N + 1, 0);
    for(int v,i=0;i<M;++i){
        cin >> v;
        V[X[i]] = v;
    } 
    
    Bt.init(N);
    Tree.init();

    for(int i=1;i<M;++i){
        auto prepos = X[i - 1];
        llt preval = V[prepos];
        auto curpos = X[i];
        llt curval = V[curpos];
        llt v = preval * curval;
        if(curpos - 1 >= prepos + 1){
            Tree.insert(prepos + 1, curpos - 1);
            for(int j=prepos+1;j<curpos;++j){
                Bt.modify(j, v);
            }            
        }
    }

#ifndef ONLINE_JUDGE
        cout << "init " << ":" << endl;
        for(int i=1;i<=N;++i){
            cout << i << ": " << V[i] << ", " << Bt.query(i, i) << endl;
        }
#endif    

    for(int t,s,e,q=1;q<=Q;++q){
        cin >> t >> s >> e;
        if(1 == t){
            auto it = Tree.shu.lower_bound({s, RangeTree::inf()});
            --it;
            if(it == Tree.shu.begin()) while(1);
            auto start = it->first.first;
            auto last = it->first.second;
            Tree.shu.erase(it);
            
            auto tmp = Bt.query(s, s);
            Bt.modify(s, -tmp);
            V[s] = e;

            auto prePos = start - 1;
            if(prePos <= 0) while(1);
            auto preVal = V[prePos];
            auto vv = preVal * e;
            if(start < s){
                Tree.insert(start, s - 1);
                for(int i=start;i<s;++i) Bt.modify(i, vv - Bt.query(i, i));
            }
            
          

            auto lastPos = last + 1;
            if(lastPos > N) while(1);
            auto lastVal = V[lastPos];
            vv = lastVal * e;
            if(s + 1 < lastPos){
                Tree.insert(s + 1, last);
                for(int i=s+1;i<lastPos;++i) Bt.modify(i, vv - Bt.query(i, i));
            }
            
        }else{
            auto ans = Bt.query(s, e);
            cout << ans << "\n";
        }

#ifndef ONLINE_JUDGE
        cout << "after " << q << ":" << endl;
        for(int i=1;i<=N;++i){
            cout << i << ": " << V[i] << ", " << Bt.query(i, i) << endl;
        }
#endif

    }
    return;
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("z.txt", "r", stdin);
#endif
    ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    int nofkase = 1;
    // cin >> nofkase;
    while(nofkase--) work();
    return 0;
}
